home *** CD-ROM | disk | FTP | other *** search
/ Amiga News 95 / Amiga News 95.iso / dpat / dpat05 / termii / documentation / xcmd.doc < prev    next >
Encoding:
Text File  |  1992-07-21  |  17.8 KB  |  443 lines

  1. Le 2 Juillet 1991
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.                                     Term II
  16.  
  17.                                   version 1.1
  18.  
  19.                         (c) 1990,1991 - Eric GONTIER
  20.  
  21.                                     XCMD.doc
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.         INTRODUCTION :
  33.  
  34.             Term II propose un système de commandes externes, qui permet  à
  35.             d'autres programmes (ou encore des "processus" Amiga) d'envoyer
  36.             des  commandes  vers  Term  II  qui  en   assure   l'exécution.
  37.             L'utilisateur ayant des notions de programmation peut donc s'il
  38.             le désirer créer  de  nouveaux  programmes  qui  ajouteront  de
  39.             nouvelles fonctions à Term. Les exemples donnés ici sont prévus
  40.             pour le langage C (et plus particulièrement le compilateur DICE
  41.             de Matt  Dillon),  mais  peuvent  être  adaptés  sans  trop  de
  42.             difficultés à d'autres langages (Modula 2, Pascal,  Aseembleur,
  43.             etc...). Cette possibilité s'ajoute à celle déjà  offerte  avec
  44.             Rexx (voir le fichier SCRIPTS.doc).
  45.  
  46.             Le "panel", c'est à dire le tableau de commande est un  exemple
  47.             très simple de processus utilisant cette possibilité. Le source
  48.             en C est fourni à titre d'exemple.
  49.  
  50.             Le  texte  suivant  décrit  le  mécanisme  des  XCMD  (eXternal
  51.             CoMmanDs) et s'adresse donc surtout au programmeur désireux  de
  52.             développer ses propres programmes).
  53.  
  54.             Si les XCMD sont une extension intéressante de  Term  II,  elle
  55.             sont aussi un formidable moyen de planter l'Amiga !
  56.  
  57.             Les XCMD permettent à un programmeur d'utiliser Term  II  comme
  58.             un ensemble de routines faciles à utiliser, tout  en  utilisant
  59.             les possibilités multi-tâches de la machine.
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.         LES XCMD :
  67.  
  68.             Grâce à l'Amiga, les XCMD ne sont  que  des  messages  échangés
  69.             entre des ports, dans la grande tradition  d'Exec.  Term  offre
  70.             aux processus externes un port appelé XTERM. C'est avec lui que
  71.             les échanges de messages se feront.  Chaque  programme  externe
  72.             doit disposer de son propre port. Dans l'exemple de "panel", le
  73.             port utilisé à pour nom PANEL.
  74.  
  75.             Une réponse doit être faite à  tout  message  reçu.  C'est  une
  76.             règle essentiel.
  77.  
  78.             Term II s'est réservé deux commandes spéciales (sous  forme  de
  79.             messages) : START et STOP. La commande START a deux objectifs :
  80.  
  81.                 - indiquer au processus externe que l'utilisateur  de  Term
  82.                   en demande une exécution.
  83.  
  84.                 - transmettre au processus des informations comme  un  lock
  85.                   sur le répertoire courant ou un lock sur l'écran  utilisé
  86.                   par Term.
  87.  
  88.             La commande QUIT est utilisé par Term II pour dire au processus
  89.             externe  de  stopper  l'exécution  et  de  libérer  toutes  les
  90.             ressources acquises.
  91.  
  92.             Les commandes qu'un processus peut envoyer vers  Term  II  sont
  93.             les commandes standards (voir le fichier  COMMANDES.doc),  plus
  94.             certaines commandes spécifiques, qui seront  décrites  dans  le
  95.             paragraphe COMMANDES SPECIALES de ce texte.
  96.  
  97.  
  98.  
  99.  
  100.  
  101.         LA STRUCTURE XCMD :
  102.  
  103.             Cette structure définit le format d'une XCMD, c'est à  dire  le
  104.             format des messages  qui  seront  échangés  entre  Term  et  le
  105.             processus externe.
  106.  
  107.                 struct XCMD
  108.                   {
  109.                   struct Message xcmd_Message;
  110.                   long           xcmd_TermCmd;
  111.                   struct Screen *xcmd_TermScreen;
  112.                   BPTR           xcmd_TermDir;
  113.                   char          *xcmd_Command;
  114.                   void          *xcmd_Args[16];
  115.                   BOOL           xcmd_TermError;
  116.                   };
  117.  
  118.             Voici la signification de chacun des champs de cette structure:
  119.  
  120.                 xcmd_Message :
  121.  
  122.                     Le message standard avec des informations  essentielles
  123.                     pour Exec, comme le "reply port" etc...
  124.  
  125.                 xcmd_TermCmd :
  126.  
  127.                     0 si non utilisé. Sinon vaut START  ou  STOP  (voir  le
  128.                     fichier XCMD.h)
  129.  
  130.                 xcmd_TermScreen :
  131.  
  132.                     Un pointeur sur l'écran utilisé  par  Term.  Il  s'agit
  133.                     d'un lock sur un public screen.
  134.  
  135.                 xcmd_TermDir :
  136.  
  137.                     lock sur le répertoire de Term II.
  138.  
  139.                 xcmd_Cmd :
  140.  
  141.                     Pointeur sur une chaine, contenant la commande  que  le
  142.                     processus externe veut faire exécuter à Term II.  Cette
  143.                     commande est soit une des commandes standards (voir  le
  144.                     fichier COMMANDES.doc) soit une commande spéciale (voir
  145.                     le paragraphe  COMMANDES  SPECIALES  de  ce  document.)
  146.  
  147.                 xcmd_Args :
  148.  
  149.                     16  pointeurs,  utiles  pour  échanger  des  arguments.
  150.                     C'est au programme appelant (donc au processus externe)
  151.                     de s'assuré que ces pointeurs pointent vers des valeurs
  152.                     effectives. Attention aux gurus !
  153.  
  154.                 xcmd_TermError :
  155.  
  156.                     Quand Term II retourne la XCMD, cette valeur vaut  TRUE
  157.                     si une erreur a été détectée. FALSE sinon.
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.         LA BOITE A OUTILS DES XCMD :
  169.  
  170.             La personne intéressée trouvera plusieurs fichiers à étudier  :
  171.  
  172.                 - XCMD.h : contient la définition de la structure  XCMD  et
  173.                 la définition des commandes START et STOP.
  174.  
  175.                 - XCMDTools.h : prototypes des  fonctions  de  la  boite  à
  176.                 outils (XCMDTools.c)
  177.  
  178.                 - XCMDTools.c : la boite à outils des XCMD,  en  sources  C
  179.  
  180.                 - XCMDTools.o : objet compilé avec DICE
  181.  
  182.                 -  Panel.c  :  un  exemple  d'utilisation  des  XCMD,  avec
  183.                 l'application "panel". La  véritable  version  est  un  peu
  184.                 différente  pour  pouvoir  être  démarrée  depuis  le  menu
  185.                 principal de Term II.
  186.  
  187.  
  188.             XCMDTool est un ensemble de petites routines dont le but est de
  189.             faciliter le travail du programmeur :
  190.  
  191.                 struct XCMD *CreateXCMD(struct MsgPort *);
  192.  
  193.                     Cette fonction crée une XCMD.  La  partie  Message  est
  194.                     correctement  initialisée.   Le   MsgPort   donnée   en
  195.                     paramètre est celui du processus externe. C'est là  que
  196.                     Term  enverra  sa  réponse  après  avoir   exécuté   la
  197.                     commande. Les autres champs sont  mise  à  0.  Si  tout
  198.                     s'est  bien  passé,  un  pointeur  sur  un   XCMD   est
  199.                     retournée, sinon NULL.
  200.  
  201.                 void DeleteXCMD(struct XCMD *);
  202.  
  203.                     Libère la mémoire utilisée par une XCMD.
  204.  
  205.                 BOOL SendXCMD(struct XCMD *);
  206.  
  207.                     Cette fonction envoie l'XCMD donnée en  paramètre  vers
  208.                     le port XTERM de Term II. Retourne TRUE si l'émission a
  209.                     pu se faire, FALSE sinon. Avant émission, cette routine
  210.                     s'assure de l'existence de XTERM. Un  couple  Forbid()-
  211.                     Permit() s'assure que XTERM n'est pas  détruit  pendant
  212.                     l'émission. Term II répondra  _toujours_  aux  messages
  213.                     reçus.  Le  programmeur  doit  tenir  compte   de   ces
  214.                     réponses.
  215.  
  216.             Ces routines n'ont bien sûr rien de miraculeux. Elles serviront
  217.             juste au programmeur débutant. Leur utilisation  n'est  pas  du
  218.             tout obligatoire.
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.         START/STOP :
  226.  
  227.             Ces commandes sont  envoyées  par  Term  II  à  la  demande  de
  228.             l'utilisateur  par  une  de  ces  fonctions  (voir  le  fichier
  229.             COMMANDES.doc) :
  230.  
  231.                 xcmd_start "nom d'un port"
  232.  
  233.                     Envoie une commande START vers le port  d'un  processus
  234.                     externe. Par  exemple  xcmd_start  "PANEL"  enverra  la
  235.                     commande START au port de nom PANEL.
  236.  
  237.                 xcmd_stop "nom d'un port"
  238.  
  239.                     Envoie une commande STOP vers le  port  d'un  processus
  240.                     externe.
  241.  
  242.             Le programmeur n'a qu'une seule obligation : il doit répondre à
  243.             ces  commandes  car  Term  II  attend  une  réponse  avant   de
  244.             poursuivre son exécution. Il est donc conseillé de répondre  le
  245.             plus rapidement possible.
  246.  
  247.             Cependant,  lors  d'une  commande  START,  Term   II   s'occupe
  248.             d'obtenir des locks sur l'écran de Term et  sur  le  répertoire
  249.             courant de l'application. Le programmeur d'un processus externe
  250.             devra donc s'assuré qu'il libère bien ces locks, par un  UnLock
  251.             pour le répertoire, et par un UnlockPubScreen pour  l'écran.  A
  252.             noter aussi que si Term II avait dans ses préférences des choix
  253.             impliquant l'ouverture d'un écran, cet écran  sera  ouvert  par
  254.             Term II pour qu'un lock sur cet écran puisse être  transmis  au
  255.             processus externe.
  256.  
  257.             De plus, il est très possible que  l'utilisateur  n'envoie  pas
  258.             ces commandes START ou STOP. Il est possible aussi dans le  cas
  259.             de certaines applications que le processus  externe  n'ait  pas
  260.             à attendre un ordre START pour  commencer  à   s'exécuter,   ou
  261.             un ordre STOP pour s'arrêter. Le  programmeur  est   libre   de
  262.             ces choix.
  263.  
  264.             Ces deux commandes sont les seules que Term II peut  envoyer  à
  265.             un  processus  externe.  Pour  le  reste,  c'est  toujours   le
  266.             processus externe qui envoie ses commandes vers  Term  II.  Les
  267.             commandes sont décrites dans le  paragraphe  suivant,  intitulé
  268.             COMMANDES SPECIALES.
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.         COMMANDES SPECIALES :
  276.  
  277.             Les commandes transmises par un processus  externe  à  Term  II
  278.             sont des commandes standards (voir le  fichier  COMMANDES.doc).
  279.             La commande est envoyée en initialisant correctement une  XCMD,
  280.             et en faisant pointer le champ  xcmd_Cmd  vers  une  chaine  de
  281.             caractères contenant la commande. Par exemple :
  282.  
  283.                 struct XCMD *xcmd = CreateXCMD(MyPort);
  284.                 if(xcmd) {
  285.                     xcmd->xcmd_Cmd = "serial_send \"ceci est un test\"";
  286.                     if(SendXCMD(XCMD))
  287.                       {
  288.                       /* XCMD bien envoyé. On attend la réponse     */
  289.                       WaitPort(MyPort);
  290.                       GetMsg(MyPort);
  291.                       /* On peut tester xcmd->xcmd_TermError pour   */
  292.                       /* savoir si tout s'est bien passé            */
  293.                       }
  294.                     }
  295.  
  296.  
  297.             Toutefois des fonctions spéciales ont été ajoutées pour que  le
  298.             programmeur puisse tirer partie des possibilités  de  Term  II.
  299.             Ainsi, les commandes réservées à ARexx, ont un équivalent  pour
  300.             les XCMD. Ces commandes sont réservées à l'usage des  XCMD,  et
  301.             peuvent transiter que par le port XTERM. Elles ne sont donc pas
  302.             reconnues si elles viennent d'un script ARexx.
  303.  
  304.             Ces commandes sont décrites ci-après, par ordre alphabétique :
  305.  
  306.  
  307.                 xcmd_delay
  308.  
  309.                     Cette commande est  l'équivalent  de  rexx_delay.  Elle
  310.                     permet de faire un délai.  xcmd_Args[0]  est  l'adresse
  311.                     d'un long contenant la valeur  du  délai  en  secondes.
  312.  
  313.                 xcmd_lock_request
  314.  
  315.                     Cette commande demande à Term II de retourner  un  lock
  316.                     sur le répertoire de Term II, et un lock sur l'écran de
  317.                     Term II. Si besoin, l'écran sera ouvert  par  Term  II.
  318.                     Cette commande est utile s'il pas prévu qu'une commande
  319.                     START soit transmise au processus extern. Le  processus
  320.                     externe devra  libérer  ces  locks  lui-même  avec  les
  321.                     fonctions UnLock et UnlockPubScreen.  Les  valeurs  des
  322.                     locks sont retournés en même temps que  la  XCMD,  dans
  323.                     les champs xcmd_TermScreen et xcmd_TermDir.
  324.  
  325.                 xcmd_memory_request
  326.  
  327.                     Cette commande demande à Term II de retoourner  les  80
  328.                     dernier caractères reçus. C'est au processus externe de
  329.                     fournir un  pointeur  valide  vers  une  chaine  de  81
  330.                     caractères (pour contenir le 0 de fin de  chaine)  dans
  331.                     laquelle Term II recopiera ces 80 caractères  (plus  le
  332.                     0 de fin de chaine). Ce pointeur doit être  placé  dans
  333.                     le champ xcmd_Args[0] de la XCMD avant d'être envoyé  à
  334.                     Term II.
  335.  
  336.                 xcmd_memory_off
  337.  
  338.                     Equivalent de rexx_memory_off. Cette commande arrête le
  339.                     mécanisme  de  memory.  Voir  le  fichier  SCRIPTS.doc.
  340.  
  341.                 xcmd_memory_on
  342.  
  343.                     Equivalent de rexx_memory_on,  cette  commande  met  en
  344.                     route  le  mécanise  de   memory.   Voir   le   fichier
  345.                     SCRIPTS.doc.
  346.  
  347.                 xcmd_setserial
  348.  
  349.                     Cette commande permet de modifier les paramètres de
  350.                     l'interface série. Elle correspond très exactement à la
  351.                     fonctions xpr_setserial décrite par Willy Langeveld
  352.                     dans la définition du standard XPR 2.0. A l'appel,
  353.                     xcmd_Args[0] doit contenir un long correspondant aux
  354.                     nouveaux paramètres. Term II retourne dans
  355.                     xcmd_Args[15] un long correspondant aux anciens
  356.                     paramètres, ou -1 en cas d'erreur. Si à l'appel
  357.                     xcmd_Args[0] vaut -1, Term II retourne les paramètres
  358.                     courants sans rien changer. Un long définissant les
  359.                     paramètres de l'interface série se compose de la
  360.                     manière suivante :
  361.  
  362.                     octet 0 : pareil que le champ SerFlags de IOExtSer
  363.                         bit 0 : parité ON si à 1
  364.                         bit 1 : parité impaire si à 1
  365.                         bit 2 : 7-wire protocole si à 1
  366.                         bit 3 : queued break si à 1
  367.                         bit 4 : rad-boogie si à 1
  368.                         bit 5 : mode partagé si à 1
  369.                         bit 6 : mode EOF si à 1
  370.                         bit 7 : protocole si à 1
  371.  
  372.                     octet 1 :
  373.                         bit 0 : parité mark ou space si à 1
  374.                         bit 1 : parité mark si à 1, space sinon
  375.                         bit 2 : 2 bits de stop si à 1, 1 sinon
  376.                         bit 3 : longueur de mots en lecture de 7 bits si à
  377.                                 1, 8 sinon
  378.                         bit 4 : longueur de mots en écriture de 7 bits si à
  379.                                 1, 8 sinon
  380.                         bit 5 : pas utilisé
  381.                         bit 6 : pas utilisé
  382.                         bit 7 : pas utilisé
  383.  
  384.                     octet 2 : vitesse, comme définit dans preferences.h
  385.                         -    110 baud = 0
  386.                         -    300 baud = 1
  387.                         -   1200 baud = 2
  388.                         -   2400 baud = 3
  389.                         -   4800 baud = 4
  390.                         -   9600 baud = 5
  391.                         -  19200 baud = 6
  392.                         -   midi      = 7
  393.                         -  38400 baud = 8
  394.                         -  57600 baud = 9
  395.                         -  76800 baud = 10
  396.                         - 115200 baud = 11
  397.  
  398.                     octet 3 : non utilisé
  399.  
  400.                 xcmd_sflush
  401.  
  402.                     Cette commande vide les buffers de l'interface série.
  403.  
  404.                 xcmd_squery
  405.  
  406.                     Cette commande permet d'obtenir le nombre de caractères
  407.                     recus et en attente de lecture dans les buffers de
  408.                     l'interface série. Term II retourne ce nombre dans
  409.                     xcmd_Args[15] ou -1 en cas d'erreur
  410.  
  411.                 xcmd_sread
  412.  
  413.                     Cette commande permet de lire des caractères depuis
  414.                     l'interface série. xcmd_Args[0] contient un pointeur
  415.                     sur un buffer, xcmd_Args[1] contient le nombre de
  416.                     caractères à lire, xcmd_Args[2] contient un timeout
  417.                     exprimé en micro-seconds. Au retour, xcmd_Args[15]
  418.                     contient le nombre de caractères lus, ou -1 en cas
  419.                     d'erreur. Si le timeout vaut 0, Term II essaiera de
  420.                     lire autant de caractères que possible : la commande
  421.                     est retournée dès qu'il n'y a plus de caractères à
  422.                     lire, ou dès que xcmd_Args[1] caractères sont lus.
  423.  
  424.                     ATTENTION : il faut s'assurer d'être bien le seul à
  425.                     lire sur l'interface série. Voir pour celà les
  426.                     commandes serial_on et serial_off dans COMMANDES.doc.
  427.  
  428.                 xcmd_swrite
  429.  
  430.                     Cette commande permet d'écrire des caractères sur
  431.                     l'interface série. xcmd_Args[0] contient l'adresse d'un
  432.                     buffer contenant les caractères à écrire, et
  433.                     xcmd_Args[1] contient le nombre de caractères à ecrire.
  434.                     Term II retourne -1 en cas d'erreur dans xcmd_Args[15]
  435.  
  436.                 xcmd_wait
  437.  
  438.                     Equivalent de la commande rexx_wait.  Voir  le  fichier
  439.                     SCRIPTS.doc. xcmd_Args[0] pointe sur un long  contenant
  440.                     la valeur du premier  délai  en  secondes.  xmd_Args[1]
  441.                     pointe sur un long contenant la valeur du second délai,
  442.                     en secondes.
  443.